from fastapi import APIRouter
from tortoise.expressions import F
from tortoise.transactions import in_transaction

from db.models.product import Product
from db.models.product_unit import ProductUnit
from db.models.store import Store
from ApiResponse import ApiResponse, DataDict
from typing import List

# 创建路由
product_router = APIRouter()


@product_router.get('/brand/dict', summary="品牌字典")
async def get_brand_list() -> ApiResponse[List[DataDict]]:
    """
    获取品牌列表接口
    返回所有未删除商品的品牌，去重处理
    """
    # 查询所有未删除商品的品牌，去重处理
    result = await Product.filter(del_flag__not="2", brand__not_isnull=True).annotate(
        label=F("brand"),
        value=F("brand")
    ).distinct().values("value", "label")

    return ApiResponse.ok(data=result, msg="品牌列表查询成功")


@product_router.get('/by-brand', summary="根据品牌查询商品")
async def get_products_by_brand(brand: str, whid: int = None) -> ApiResponse[List[dict]]:
    """
    根据品牌查询商品接口
    返回指定品牌的所有商品信息

    参数:
    - brand: 品牌名称
    - whid: 仓库ID（可选），如果提供则返回商品在指定仓库的可用数量
    """
    # 查询指定品牌的未删除商品
    products = await Product.filter(
        del_flag__not="2",
        brand=brand
    ).values(
        "pid", "pname", "brand", "formulatext", "formulanum",
        "smallunit", "smallprice", "bigunit", "bigprice"
    )

    # 处理每个商品的单位信息
    products_with_units = []
    for product in products:
        unitlist = []

        # 如果smallunit不为空，添加小单位信息
        if product["smallunit"]:
            unitlist.append({
                "unitname": product["smallunit"],
                "unitprice": float(product["smallprice"]) if product["smallprice"] else 0.0
            })

        # 如果bigunit不为空，添加大单位信息
        if product["bigunit"]:
            unitlist.append({
                "unitname": product["bigunit"],
                "unitprice": float(product["bigprice"]) if product["bigprice"] else 0.0
            })

        # 查询商品在指定仓库的可用数量（如果提供了whid）
        availablenum = None
        if whid is not None:
            store_item = await Store.filter(
                pid=product["pid"],
                whid=whid,
                del_flag__not="2"
            ).first()

            if store_item and hasattr(store_item, 'availablenum') and store_item.availablenum is not None:
                availablenum = float(store_item.availablenum)

        # 构建包含单位列表的商品信息
        product_with_units = {
            "pid": product["pid"],
            "pname": product["pname"],
            "brand": product["brand"],
            "formulatext": product["formulatext"],
            "smallunit": product["smallunit"],
            "smallprice": float(product["smallprice"]) if product["smallprice"] else 0.0,
            "bigunit": product["bigunit"],
            "bigprice": float(product["bigprice"]) if product["bigprice"] else 0.0,
            "formulanum": product["formulanum"],
            "unitlist": unitlist
        }

        # 如果查询到了可用数量，添加到返回结果中并计算单位数量
        if availablenum is not None:
            product_with_units["availablenum"] = availablenum

            # 计算大单位和小单位数量
            if product["bigunit"] and product["formulanum"] and product["formulanum"] > 0:
                # 有大单位，计算箱数和瓶数
                bigunitnum = int(availablenum // product["formulanum"])
                smallunitnum = int(availablenum % product["formulanum"])

                product_with_units["bigunitnum"] = bigunitnum
                product_with_units["smallunitnum"] = smallunitnum
            else:
                # 没有大单位，只有小单位数量
                product_with_units["bigunitnum"] = 0
                product_with_units["smallunitnum"] = int(availablenum)

        products_with_units.append(product_with_units)

    return ApiResponse.ok(data=products_with_units, msg="商品查询成功")


@product_router.post('/migrate-units', summary="迁移商品单位数据")
async def migrate_product_units() -> ApiResponse[dict]:
    """
    迁移商品单位数据接口
    清空wms_product_unit表，然后从wms_product表迁移单位数据
    """
    try:
        async with in_transaction():
            # 清空wms_product_unit表中的所有数据（软删除）
            await ProductUnit.filter(del_flag__not="2").update(del_flag="2")

            # 读取wms_product表中的所有未删除商品
            products = await Product.filter(del_flag__not="2").all()

            migrated_count = 0

            # 处理每个商品
            for product in products:
                # 如果bigunit和bigprice不为空，插入一条记录
                if product.bigunit:
                    big_unit = await ProductUnit.create(
                        pid=product.pid,
                        unit=product.bigunit,
                        unitprice=float(product.bigprice) if product.bigprice else 0.0,
                        create_time=product.create_time,
                        create_by=product.create_by,
                        update_time=product.update_time,
                        update_by=product.update_by,
                        remark=f"从商品迁移 - 大单位"
                    )
                    migrated_count += 1

                # 如果smallunit和smallprice不为空，插入一条记录
                if product.smallunit:
                    small_unit = await ProductUnit.create(
                        pid=product.pid,
                        unit=product.smallunit,
                        unitprice=float(product.smallprice) if product.smallprice else 0.0,
                        create_time=product.create_time,
                        create_by=product.create_by,
                        update_time=product.update_time,
                        update_by=product.update_by,
                        remark=f"从商品迁移 - 小单位"
                    )
                    migrated_count += 1

            return ApiResponse.ok(
                data={
                    "migrated_units": migrated_count,
                    "processed_products": len(products)
                },
                msg=f"商品单位数据迁移完成，共迁移{migrated_count}个单位"
            )

    except Exception as e:
        return ApiResponse.error(500, f"商品单位数据迁移失败: {str(e)}")
